apps/tauri/src-tauri/src/sessions.rs (1)

177-191: Consider batching queries for efficiency.

The current implementation executes N separate queries (one per workspace path). For typical usage with a small number of workspaces, this is fine. However, if the workspace count grows, a single query with an IN clause would be more efficient.

♻️ Optional: Single-query approach

 pub fn count_sessions_batch(conn: &Connection, workspace_paths: &[String]) -> Result<Vec<(String, i64)>, String> {
-    let mut results = Vec::with_capacity(workspace_paths.len());
-    let mut stmt = conn
-        .prepare("SELECT COUNT(*) FROM sessions WHERE workspace_path = ?1")
-        .map_err(|e| format!("Prepare error: {}", e))?;
-    for path in workspace_paths {
-        let count: i64 = stmt
-            .query_row(params![path], |row| row.get(0))
-            .unwrap_or(0);
-        if count > 0 {
-            results.push((path.clone(), count));
-        }
-    }
-    Ok(results)
+    if workspace_paths.is_empty() {
+        return Ok(Vec::new());
+    }
+    let placeholders: Vec<_> = (1..=workspace_paths.len()).map(|i| format!("?{}", i)).collect();
+    let sql = format!(
+        "SELECT workspace_path, COUNT(*) FROM sessions WHERE workspace_path IN ({}) GROUP BY workspace_path HAVING COUNT(*) > 0",
+        placeholders.join(", ")
+    );
+    let mut stmt = conn.prepare(&sql).map_err(|e| format!("Prepare error: {}", e))?;
+    let params: Vec<&dyn rusqlite::ToSql> = workspace_paths.iter().map(|p| p as &dyn rusqlite::ToSql).collect();
+    let rows = stmt
+        .query_map(params.as_slice(), |row| Ok((row.get::<_, String>(0)?, row.get::<_, i64>(1)?)))
+        .map_err(|e| format!("Query error: {}", e))?
+        .collect::<Result<Vec<_>, _>>()
+        .map_err(|e| format!("Row error: {}", e))?;
+    Ok(rows)
 }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@apps/tauri/src-tauri/src/sessions.rs` around lines 177 - 191, The current
count_sessions_batch runs one query per workspace_path; change it to issue a
single SQL query using "SELECT workspace_path, COUNT(*) FROM sessions WHERE
workspace_path IN (?1,?2,...) GROUP BY workspace_path" to improve performance:
in count_sessions_batch build dynamic placeholders matching
workspace_paths.len(), return early with empty vec if workspace_paths is empty,
prepare that single statement (instead of the existing per-path stmt), bind all
workspace_paths as params, iterate over rows to push (workspace_path, count)
into results, and preserve the same Result<Vec<(String,i64)>, String> error
handling.

apps/tauri/src/components/HomeScreen.tsx (1)

38-51: Dependency array pattern creates unnecessary closures.

The dirWorkspaces.map((w) => w.path).join(",") in the dependency array (line 51) is evaluated on every render before comparison. While the resulting string is stable when paths don't change, the intermediate .map() call allocates a new array each time. Consider memoizing the paths or moving the filtering logic inside the callback.

The same pattern exists in fetchCommentCounts (line 36). Both could be simplified:

♻️ Suggested improvement using useMemo

+  const dirPaths = useMemo(() => dirWorkspaces.map((w) => w.path), [dirWorkspaces]);
+  const filePaths = useMemo(() => fileWorkspaces.map((w) => w.path), [fileWorkspaces]);

   const fetchCommentCounts = useCallback(async () => {
-    if (fileWorkspaces.length === 0) return;
-    const paths = fileWorkspaces.map((w) => w.path);
+    if (filePaths.length === 0) return;
     try {
-      const results = await invoke<[string, number][]>("count_unresolved_comments", { filePaths: paths });
+      const results = await invoke<[string, number][]>("count_unresolved_comments", { filePaths });
       // ...
     } catch {
       // silently ignore
     }
-  }, [fileWorkspaces.map((w) => w.path).join(",")]);
+  }, [filePaths]);

   const fetchSessionCounts = useCallback(async () => {
-    if (dirWorkspaces.length === 0) return;
-    const paths = dirWorkspaces.map((w) => w.path);
+    if (dirPaths.length === 0) return;
     try {
-      const results = await invoke<[string, number][]>("count_workspace_sessions", { workspacePaths: paths });
+      const results = await invoke<[string, number][]>("count_workspace_sessions", { workspacePaths: dirPaths });
       // ...
     } catch {
       // silently ignore
     }
-  }, [dirWorkspaces.map((w) => w.path).join(",")]);
+  }, [dirPaths]);

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@apps/tauri/src/components/HomeScreen.tsx` around lines 38 - 51, The
dependency array currently calls dirWorkspaces.map(...).join(",") which
allocates on every render and causes unnecessary closures in fetchSessionCounts
(and similarly fetchCommentCounts); fix by memoizing the derived paths with
useMemo (e.g. const workspacePaths = useMemo(() => dirWorkspaces.map(w =>
w.path), [dirWorkspaces]) and then use workspacePaths (or
workspacePaths.join(",")) in the dependency arrays, or alternatively move the
mapping inside fetchSessionCounts and depend directly on dirWorkspaces to avoid
the repeated map allocation. Ensure you update both fetchSessionCounts and
fetchCommentCounts to reference the memoized workspacePaths or dirWorkspaces
consistently.

apps/tauri/src/components/WorkspaceCard.tsx (1)

86-98: Badge positioning relies on mutual exclusivity.

Both badges use identical absolute top-1.5 right-1.5 positioning. Currently this works because unresolvedComments is only passed to file workspaces and sessionCount to directory workspaces (they're mutually exclusive). However, this creates a maintenance hazard if future changes allow both badges on the same card.

Consider making this explicit with a comment, or restructuring to handle potential co-existence:

💡 Option: Add clarifying comment

+      {/* Note: unresolvedComments and sessionCount are mutually exclusive by workspace type */}
       {unresolvedComments != null && unresolvedComments > 0 && (
         <span className="absolute top-1.5 right-1.5 inline-flex items-center gap-0.5 text-muted-foreground group-hover:opacity-0 transition-opacity">

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@apps/tauri/src/components/WorkspaceCard.tsx` around lines 86 - 98, The two
badges (unresolvedComments and sessionCount) in WorkspaceCard share identical
absolute positioning ("absolute top-1.5 right-1.5") which will cause overlap if
both become present; update WorkspaceCard to either (a) render a single
top-right badge container and place both badges inside it using a vertical or
horizontal layout with spacing (e.g., a flex column/row with gap) so they don't
collide, or (b) give each badge distinct offsets (e.g., top-1.5 right-1.5 and
top-1.5 right-6) so they stack, and add a brief inline comment above the badge
rendering explaining the choice; ensure you reference and conditionally render
unresolvedComments and sessionCount inside that adjusted container.

Configuration used: defaults

Review profile: CHILL

Plan: Pro

Configuration used: defaults

Review profile: CHILL

Plan: Pro